package com.itheima.d0_feedback;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.function.Consumer;

public class 反馈 {
    public static void main(String[] args)  {
        String qq = "023123123";

        //QQ：1，全部都是数字，2 不能以0开头，3 6~15位
        String regex = "[1-9]\\d{5,14}";

        //通过String的matches方法来进行校验
        if (qq.matches(regex)) {
            System.out.println("QQ合法的");
        } else {
            System.out.println("不合法");
        }


        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");

        int age = 10;//有效的final变量。(如果能够保证变量不会被二次改变，就叫做有效的final)

        //age = 20; //不能改变了

        int myAge = age;
        myAge = 10;

        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String name) {
                System.out.println("name = " + name + age);
            }
        });
        list.forEach(name -> System.out.println(name + age));


        try {
            a();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


     public static void a() throws Exception {
        b();
     }

    private static void b() throws Exception {
        c();
    }

    private static void c() throws Exception {
        //throw new Exception();
        setAge(100);
    }

    public static void setAge(int age) throws AgeException {
        if (age<0||age>150) {
            throw new AgeException("年龄不合法");
        }
    }
}

class AgeException extends Exception{
    public AgeException() {
    }

    public AgeException(String message) {
        super(message);
    }
}


class Demo2{
    public static void main(String[] args) {
        //使用LinkedList实现下队列：先进先出
        LinkedList<String> queue = new LinkedList<>();
        /*
             ------------
         队头                 队尾
             ------------
         */

        queue.addFirst("A");//先进
        queue.addFirst("B");
        queue.addFirst("C");
        queue.addFirst("D");
        System.out.println("queue = " + queue);
        String e = queue.removeLast();//先出
        System.out.println("e = " + e); //A


        //使用LinkedList实现下栈：先进后出,后进先出
        /*
                  -----------|
            栈顶              |   栈底
                  -----------|
         */
        LinkedList<String> stack = new LinkedList<>();
        //进栈，压栈
        stack.addFirst("A");
        stack.addFirst("B");
        stack.addFirst("C");
        System.out.println("stack = " + stack);
        //出栈，弹栈
        System.out.println(stack.removeFirst());//C
        System.out.println(stack.removeFirst());//B
        System.out.println(stack.removeFirst());//A

       // List<String> list = Arrays.asList("A", "B", "C");
       // list.add("D");

    }
}

/*
  1，运用正则表达式对数据进行判断这个点还是不太会

  2，Lambda表达式中使用的变量应该是final或有效final，讲一下Lambda表达式中的变量问题

  3，捕获异常不太明白
    捕获异常就是使用try-catch关键字处理异常，表示背锅。
  4,异常什么时候应该甩锅，什么时候应该背锅？
    一般的做法就是底层进行throws出去，上层就行try-catch

  5，自定义异常，书写的步骤是什么，有点不懂怎么写。
    1）继承一个异常类（Exception，RuntimeException）
    2）写构造方法
    3）在判断数据不合法的地方，throw  new 异常对象();

  6,LinkedList的队列和栈对象的创建不是很清楚
    LinkedList中存在一些对首尾进行操作的方法，可以很方便的实现队列，栈这种结构
 */